
import moment from 'moment'
// 将UTC时间转化为北京时间
export function utoTimeToBeijing(value) {
  if (value != null) {
    return new Date(+new Date(new Date(value).toJSON()) + 8 * 3600 * 1000).toISOString().replace(/T/g, ' ').replace(/\.[\d]{3}Z/, '')
  }
  return null
}
// 格式化时间
export function utoTime(value,fmt) {
  if (value) {
    return moment(value).format(fmt);
  }
  return null
}
// 将UTC时间转换为年月日
export function utoDateToBeijing(value) {
  if (value != null) {
    const date1 = new Date(value).toJSON()
    const date = new Date(+new Date(date1) + 8 * 3600 * 1000).toISOString().replace(/T/g, ' ').replace(/\.[\d]{3}Z/, '')
    return date.substr(0, 10) // 接取2020-04-02
  }
  return null
}

// 数据字典取值
export function findEnumLabel(code, enums) {
  if(code!=null){
    let codeSrc = code.toString()
    // 多选枚举字典
    if(codeSrc.indexOf(',') > 0){
      let array = codeSrc.split(',')
      let src = "";
      for(let i = 0; i < array.length; i++){
        for (const key in enums) {
          const item = enums[key]
          if (item.value === array[i]) {
            if(i === 0) {
              src += item.label
            } else {
              src += ','+ item.label
            }
          }
        }
      }
      return src
    } else {
      // 单选枚举字典
      for (const key in enums) {
        const item = enums[key]
        if (item.value === codeSrc) {
          return item.label
        }
      }
    }
  }
  return ''
}

/**
 * 根据外键，返回其指定的属性数据
 *
 * @param id 该外键id
 * @param ary 该外键数组集合
 * @param attribute 该展示列 需返回属性
 */
export function  findForeignKey(id, ary, attribute) {
  let newObj = ary.find(item => item.id === id)
  if(newObj != null){
    return newObj[''+attribute]
  }

  return null
}
/**
 * 将对应的Id 转为特殊的属性名称，用于table展示
 * @param code 多选时则为  '1，22，3'
 * @param array根据对应的值，  数据集合
 * @param attributeName  想转换数组中具体属性
 * @returns {string|*}
 */
export function conversionIdToAttributeName(code, array, attributeName) {
  if (code != null) {
    const codeSrc = code.toString()
    // 多选枚举字典
    if (codeSrc.indexOf(',') > 0) {
      const codeArray = codeSrc.split(',')
      let src = "";
      for (let i = 0; i < codeArray.length; i++) {
        // 单选转换
        for (const key in array) {
          const item = array[key]
          if (item.value.toString() === codeArray[i]) {
            src += item[attributeName]
            if (i !== codeArray.length - 1) {
              src += ","
            }
          }
        }
      }
      return src
    } else {
      // 单选转换
      for (const key in array) {
        const item = array[key]
        if (item.value.toString() === codeSrc) {
          return item[attributeName]
        }
      }
    }
  }
  return ''
}

function findChildLabel (code, children, values, prop) {
  for (const i in children) {
    const item = children[i];
   // console.log('=======item', item, values, prop)
    if (code == item[values]) {
      return item[prop];
    }
    if (item.children) {
      const s = findChildLabel(code, item.children, values, prop);
      if (s) {
        return s
      }
    }
  }
  return "";
}

/**
 *  表格内过滤器方法，（动态表格）
 * @param code 根据对应的值 '1，22，3'
 * @param enums 数据集合
 * @param prop  树形结构中label
 * @param values  树形结构中value
 * @returns {string|*}
 */
export function filterFun(code, enums, prop,values) {
  // console.log('code',code,'enums',enums,'prop',prop ,'values',values)
  if(code!=null){
    let codeSrc = code.toString()
    // 多选枚举字典
    if(codeSrc.indexOf(',') > 0){
      let array = codeSrc.split(',')
      let src = "";
      for(let i = 0; i < array.length; i++){
        for (const key in enums) {
          const item = enums[key]
          if (item[values] == array[i]) {
            if(i == 0) {
              src += item[prop]
            } else {
              src += ','+ item[prop]
            }
          }
        }
      }
      return src
    } else {
      // 单选枚举字典
      for (const key in enums) {
        const item = enums[key]
        if (item[values] == codeSrc) {
          return item[prop]
        } else {
          if (item.children) {
            const s = findChildLabel(codeSrc, item.children, values, prop)
            if (s) {
              return s
            }
          }
        }
      }
    }
  }
  return ''
}
/**
 *  表格内过滤器方法，（动态表格）布尔值
 * @param code 根据对应的值 true,false
 * @param enums 数据集合
 * @param prop  数据结构中label
 * @param values  树形结构中value
 * @returns {string|*}
 */
export function filterFunBoolean(code, enums,prop,values) {
  // console.log('code',code,'enums')
  if(code ===true || code ===false){
    for (const key in enums) {
      const item = enums[key]
      if (item[values] == code) {
        return item[prop]
      }
    }
  }else{
    return ''
  }
}
/**
 *  表格内树形结构过滤器方法，（动态表格）树形结构(只显示最后一级)
 * @param val 根据对应的值 '1，22，3'
 * @param treeData 数据集合
 * @param labels  树形结构中label
 * @param values  树形结构中value
 * @param sign  中间符号形式，如','或者'/'
 * @returns {string|*}
 */
export function filterFunTree(val, treeData, labels,values,sign) {
  if(val!=null){
    var text = '';
    let codeSrc = val.toString();
    let convert = (arr) => {
      arr.forEach((item,index) => {
        if(item[values] == codeSrc){
          text = item[labels]
        }else{
          if(item.children && item.children.length > 0){
            return convert(item.children)
          }
        }
      })
    }
    if (treeData) {
      convert(treeData)
    }
    return text
  }
  return ''
}
/**
 *  表格内树形结构过滤器方法，（动态表格）树形结构(显示全级，不是最后一级)
 * @param val 根据对应的值 '1，22，3'
 * @param treeData 数据集合
 * @param labels  树形结构中label
 * @param values  树形结构中value
 * @param sign  中间符号形式，如','或者'/'
 * @returns {string|*}
 */
 export function filterFunTreeAll(val, treeData, labels,values,sign) {
  if(val!=null){
    var text = '';
    let codeSrc = val.toString();
    let array = codeSrc.split(',');
    let convert = (arr) => {
      arr.forEach((item,index) => {
        array.forEach((item1,index1)=>{
          if(item[values] == item1){
            if(index1 == 0){
              text += item[labels]
            }else{
              text += sign + item[labels]
            }
            if(item.children && item.children.length > 0){
              return convert(item.children)
            }
          }
        })
      })
    }
    if (treeData) {
      convert(treeData)
    }
    return text
  }
  return ''
}